home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Precision Software Appli…tions Silver Collection 1
/
Precision Software Applications Silver Collection Volume One (PSM) (1993).iso
/
tutor
/
modula12.exe
/
CHAP2.TXT
< prev
next >
Wrap
Text File
|
1988-10-26
|
15KB
|
322 lines
Chapter 2 - Getting started in Modula-2
OUR FIRST MODULA-2 PROGRAM
We are ready to look at our first instructional program
in Modula-2. Assuming that you have a full screen editor of
some type, load the program PUPPYDOG.MOD and display it on
your screen. It is an example of the minimum Modula-2
program. There is nothing that can be left out of this
program and still have a compileable, executable program.
The first word in the program, "MODULE", is the name
that identifies a module, and it must be written as given
here, in all capital letters. During the entire first part
of this tutorial, we will use only this type of a module.
There are other types but we will not look at any of them
until we get to part III of this tutorial. Modula-2
requires us to name our module so we give it a name,
"PuppyDog". We could have used any name that qualifies as
an identifier but we have chosen a name that has nothing to
do with computers as an illustration that any name could be
used. In a practical program, you would probably use a name
that was descriptive of the program in some way.
WHAT IS AN IDENTIFIER?
An identifier is a combination of letters and numbers
that Modula-2 uses to identify a variable, program name,
procedure name, and several other quantities. In Modula-2,
an identifier is composed of any number of characters. The
characters may be any mix of alphabetic and numeric
characters, but the first character must be an alphabetic
character. The case of the alphabetic character is
significant such that "IdentNumber1", "IDENTNUMBER1", and
"IdEnTnUmBeR1" are all different identifiers. No spaces or
any other special characters are allowed.
BACK TO THE PROGRAM UNDER CONSIDERATION
The "header" line is terminated with a semicolon
according to the formal definition of Modula-2. A semicolon
is a statement separator and many will be used in large
programs. Following the semicolon, we come to the program
itself. The program statements are enclosed between the two
words "BEGIN" and "END". In this case there are no
statements, but if there were some, they would be placed
between the two indicated words. Finally, the module name
is repeated after the "END" and it is followed by a period.
The module name is repeated in order to make the program
easier to understand by clearly marking its limits. In this
case it really doesn't add to the clarity of the program,
but in a large program it can be of significant help. The
period marks the end of the listing and can be thought of as
Page 8
Chapter 2 - Getting started in Modula-2
the period that marks the end of a sentence.
The three words, MODULE, BEGIN, and END, are special
words in Modula-2. They are "reserved words" because they
are used for a specific purpose and cannot be used for any
other purpose. They are not available for your use in any
way except for the defined purpose. The reserved words in
Modula-2 are always capitalized or the compiler will not
consider them as reserved words. Remember that alphabetic
characters must have the correct case in Modula-2. Some
other languages, most notably Pascal, allow you to use
either case anywhere and it converts them internally so that
they are the same. It would be permissible for you to use
words such as "Begin" or "End" as variables in a Modula-2
program, but it would be very poor programming practice and
should be avoided. We will come across many other reserved
words in these lessons. There are 40 reserved words in
Modula-2.
You should have learned how to use your compiler by now
so you can compile and run this program. It will do
nothing, but that is significant in itself, because it
should at least return to the operating system after it
finishes doing nothing. That may sound a little silly, but
it does take a considerable amount of effort to load,
transfer control to the program, and set up linkage back to
your Disk Operating System.
It should be noted at this time that the Modula-2
compiler doesn't care about extra blanks or linefeeds and
the careful programmer will insert extra blanks and
linefeeds as desired in order to make the program easier to
read. As you continue to program in Modula-2, you will no
doubt develop a style of your own and hopefully your
programs can be read easily by other programmers.
A PROGRAM THAT DOES SOMETHING
Load and display the program named WRITESM.MOD for an
example of a Modula-2 program that does something. First
you should notice that the elements of the first program are
still here as they will be in every Modula-2 program. The
same three reserved words are used here as before, but now
there are some added statements.
The line near the beginning that begins with the
reserved word "FROM" is a special line that must be used in
any program that accesses external procedures. We will not
try to define this line at this time. We will only say that
every external call in Modula-2 requires a definition of
where to find the procedure. The module named "InOut" is a
Page 9
Chapter 2 - Getting started in Modula-2
collection of input and output routines that are available
for our use and this line in the program tells the system to
look in the "InOut" collection for the procedures named
"WriteLn" and WriteString". When the program needs these
particular functions to do what we ask it to do, it knows
where to find them. We will cover the IMPORT list in detail
later in this tutorial. Until then, simply use the example
programs as a guide when you wish to write a practice
program.
OUR FIRST PROGRAM STATEMENTS
Between the BEGIN and END statements, which we defined
previously as the place where the actual program is placed,
we have a series of "WriteString" and WriteLn" statements.
These statements are almost self explanatory, but we will
say a few words about them anyway. Each line is a call to a
"procedure" which is a very important feature of Modula-2.
A "procedure" is an external servant that does a certain job
for us in a well defined way. In the case of the
"WriteString", it looks at the string of characters supplied
to it and displays the string of characters on the monitor
at the current cursor position. In the case of the "WriteLn"
procedure, it serves us by moving the cursor down one line
on the monitor and moving it to the left side of the screen.
The parentheses are required for the WriteString
because it has data following it. The data within the
parentheses is data supplied to our slave or helper. It
gets the string of characters between the quotation marks or
the apostrophes and displays the string on the monitor. You
have a choice of delimiters so that you can output the
delimiters themselves. If you desire to output a quotation
mark to the monitor, use apostrophes for delimiters, and if
you wish to output apostrophes, use quotation marks. If you
wish to output both, break the line up and output it
piecemeal as in the last example line.
This program should be very clear to you by now. First
we tell the system where to get the procedures, then we list
the procedures in the order required to produce the desired
results. It should be apparent that the lines of the
program between the reserved words BEGIN and END are simply
executed in order. Compile and run the program and observe
the output on your monitor. It should be mentioned at this
point that it is possible to redirect the output to the
printer or to a disk file but we will not be doing that for
quite some time. We will stay with the basic syntax of
Modula-2 for now.
Page 10
Chapter 2 - Getting started in Modula-2
MODULA-2 COMMENTS
No program is complete without a few comments embedded
in the program as notes to the programmer describing the
reasons for doing some particular thing. The notes are
particularly helpful to another programmer who needs to
modify the program some day. It is not necessary for the
computer to understand the notes and in fact, you don't want
the computer to try to understand the notes, so you tell the
compiler to ignore the notes completely. How to do this is
the object of our next program named MODCOMS.MOD which you
should load and display on your monitor.
In Modula-2, comments are enclosed in pairs of double
characters. The comment is started with the "(*", and ended
with the "*)". The program on your monitor has several
examples of comments in it. If the comments were completely
removed, the program would be very similar to the last one
but a lot shorter. Notice that comments can go nearly
anywhere in a program, even before the header statement or
after the ending period. Comments can be used to remove a
section of program from consideration by the compiler so
that a particularly troublesome section of code can be
"commented out" until you solve some of the other problems
in program debugging. It is important to remember that
comments can be "nested" in Modula-2 so that a section of
code can be "commented out" even if it contains other
comments.
This particular program is not meant to be an example
of good commenting. It is really a sloppy looking program
that would need some work to put it into a good style, but
it does illustrate where it is possible to put comments.
GOOD PROGRAMMING STYLE
Load and display the program named GOODFORM.MOD for an
example of a well formatted program. Since Modula-2 allows
you to use extra spaces and blank lines freely, you should
use them in any way you can to make your programs easy to
understand, and therefore easy to debug and modify. Special
care has been given to style in this program and it payed
off in a very easy to understand program. Even with your
very limited knowledge of Modula-2 programming you can very
quickly decipher what it does. It is so well formatted that
comments are not needed and they would probably detract from
its readability. No further comment is needed or will be
given. Compile and run this program to see if it does what
you think it will do.
Page 11
Chapter 2 - Getting started in Modula-2
REALLY BAD FORMATTING
Load and display UGLYFORM.MOD for an excellent example
of bad formatting. If you can see at a glance what this
program does you deserve the Nobel Prize for understanding
software if such a thing exists. The syntax for this
program follows all of the rules of Modula-2 programming
except for good style. Without saying anything else about
this mess, I would suggest that you try to compile and run
it. You may be surprised to find that it does compile and
run, and in fact it is identical to the last program. Keep
in mind that you can add extra blanks and linefeeds anyplace
you desire in a program to improve its readability.
Hopefully, the last two programs will be an indication
to you that good programming style is important and can be a
tremendous aid in understanding what a program is supposed
to do. You will develop your own programming style as time
goes by. It is good for you to spend some effort in making
your program look good, but don't get too excited about it
yet. Initially, you should expend your effort in learning
how to program in Modula-2 with reasonable style and strive
to improve your style as you go along. It would be good for
now if you simply tried to copy the style given in these
lessons.
PROGRAMMING EXERCISES
1. Write a program that will display your name on the
monitor.
2. Write a program that will display your name on the
monitor along with your address, city and state in 3
separate lines.
3. Add a comment to the MODCOMS.MOD file between the words
"IMPORT" and "WriteLn" to see if the compiler will
allow you to put a comment within a statement.
Page 12